/**
 * 材质引用管理工具
 * 用于统一管理材质在场景节点中的引用关系
 */

/**
 * 更新材质引用（添加或删除）
 * @param {string} projectId - 项目ID
 * @param {string} materialId - 材质ID
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @param {string} meshName - Mesh名称（稳定标识）
 * @param {string} meshDisplayName - Mesh显示名称（可选）
 * @param {string} action - 操作类型 'add' | 'remove'
 * @returns {Promise<boolean>} - 操作是否成功
 */
export async function updateMaterialReference(projectId, materialId, sceneId, nodeId, meshName, meshDisplayName, action = 'add') {
    try {
        // 跳过无效的materialId（如 "0" 表示使用自身材质）
        if (!materialId || materialId === "0") {
            return false;
        }
        
        if (!meshName) {
            console.warn('⚠️ [Material Reference] meshName is required');
            return false;
        }
        
        const response = await fetch(`/api/projects/${projectId}/materials/${materialId}/node-references`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                sceneId,
                nodeId,
                meshId: meshName, // ⚡ 后端API仍使用 meshId 字段名（但值是 meshName）
                meshName: meshDisplayName || meshName,
                action
            })
        });
        
        const result = await response.json();
        
        if (result.success) {
            return true;
        } else {
            console.warn(`⚠️ [Material Reference] ${action === 'add' ? '添加' : '移除'}引用失败:`, result.error);
            return false;
        }
    } catch (error) {
        console.error(`❌ [Material Reference] ${action === 'add' ? '添加' : '移除'}引用出错:`, error);
        return false;
    }
}

/**
 * 添加材质引用
 * @param {string} projectId - 项目ID
 * @param {string} materialId - 材质ID
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @param {string} meshName - Mesh名称（稳定标识）
 * @param {string} meshDisplayName - Mesh显示名称
 * @returns {Promise<boolean>}
 */
export async function addMaterialReference(projectId, materialId, sceneId, nodeId, meshName, meshDisplayName) {
    return updateMaterialReference(projectId, materialId, sceneId, nodeId, meshName, meshDisplayName, 'add');
}

/**
 * 移除材质引用
 * @param {string} projectId - 项目ID
 * @param {string} materialId - 材质ID
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @param {string} meshName - Mesh名称（稳定标识）
 * @param {string} meshDisplayName - Mesh显示名称
 * @returns {Promise<boolean>}
 */
export async function removeMaterialReference(projectId, materialId, sceneId, nodeId, meshName, meshDisplayName) {
    return updateMaterialReference(projectId, materialId, sceneId, nodeId, meshName, meshDisplayName, 'remove');
}

/**
 * 批量更新材质引用（用于一个节点有多个mesh使用不同材质的情况）
 * ⚡ 优化：按材质分组，避免并发写入同一个材质文件
 * @param {string} projectId - 项目ID
 * @param {Object} meshMaterials - mesh材质绑定对象
 *   - 新格式：{ meshName: "materialDisplayName", ... }
 *   - 旧格式：{ meshName: { materialId, meshName, ... }, ... }
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @param {string} action - 操作类型 'add' | 'remove'
 * @returns {Promise<Object>} - { success: number, failed: number }
 */
export async function batchUpdateMaterialReferences(projectId, meshMaterials, sceneId, nodeId, action = 'add') {
    const results = {
        success: 0,
        failed: 0
    };
    
    if (!meshMaterials || Object.keys(meshMaterials).length === 0) {
        return results;
    }
    
    // 按材质分组
    const materialGroups = new Map();
    
    for (const [meshName, binding] of Object.entries(meshMaterials)) {
        let materialDisplayName;
        let meshDisplayName = meshName;
        
        if (typeof binding === 'string') {
            materialDisplayName = binding;
        } else if (typeof binding === 'object' && binding !== null) {
            materialDisplayName = binding.materialId || binding.displayName;
            meshDisplayName = binding.meshName || meshName;
        } else {
            console.warn(`⚠️ 无效的材质绑定格式:`, binding);
            continue;
        }
        
        if (!materialDisplayName || materialDisplayName === "0") {
            continue;
        }
        
        if (!materialGroups.has(materialDisplayName)) {
            materialGroups.set(materialDisplayName, []);
        }
        
        materialGroups.get(materialDisplayName).push({
            meshId: meshName,
            meshName: meshDisplayName
        });
    }
    
    // 批量更新
    const promises = Array.from(materialGroups.entries()).map(async ([materialDisplayName, meshes]) => {
        try {
            const url = `/api/projects/${projectId}/materials/${encodeURIComponent(materialDisplayName)}/node-references`;
            
            const response = await fetch(url, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    sceneId,
                    nodeId,
                    meshes,
                    action
                })
            });
            
            const result = await response.json();
            
            if (result.success) {
                const stats = result.data?.stats || {};
                const count = stats.added || stats.removed || meshes.length;
                results.success += count;
                return true;
            } else {
                console.warn(`⚠️ 材质引用${action === 'add' ? '添加' : '移除'}失败: ${materialDisplayName}`, result.error);
                results.failed += meshes.length;
                return false;
            }
        } catch (error) {
            console.error(`❌ 材质引用${action === 'add' ? '添加' : '移除'}出错:`, error);
            results.failed += meshes.length;
            return false;
        }
    });
    
    await Promise.all(promises);
    
    return results;
}

/**
 * 添加节点的所有材质引用
 * @param {string} projectId - 项目ID
 * @param {Object} meshMaterials - mesh材质绑定对象
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @returns {Promise<Object>}
 */
export async function addNodeMaterialReferences(projectId, meshMaterials, sceneId, nodeId) {
    return batchUpdateMaterialReferences(projectId, meshMaterials, sceneId, nodeId, 'add');
}

/**
 * 移除节点的所有材质引用
 * @param {string} projectId - 项目ID
 * @param {Object} meshMaterials - mesh材质绑定对象
 * @param {string} sceneId - 场景ID
 * @param {string} nodeId - 节点ID
 * @returns {Promise<Object>}
 */
export async function removeNodeMaterialReferences(projectId, meshMaterials, sceneId, nodeId) {
    return batchUpdateMaterialReferences(projectId, meshMaterials, sceneId, nodeId, 'remove');
}

